﻿

namespace Acoris.Core
{
    using Acoris.Foundation;
    using Acoris.Rendering;
    using Acoris.Template;

    using System;
    using System.Collections;
    using System.Collections.Generic;

    using SynchronizeObject = System.Object;

    // 模板系统主要完成样式、版式、模板的存储，并且提供一套支持查询的API。它定义了下列的关键字，用于修改元素的样式：
    // 1) 版式
    //
    // 版式包含了包括顶层元素的所有元素的默认样式，一般应用会提供一个通用的默认版式，但是用户可以根据自己的需要，可以
    // 通过设计器协助或者是手工构造属于自己的版式。版式的样式将会应用到所有元素上面。
    //
    // 2) 模板
    // 
    // 模板可以让用户定义一组固定的组合元素，这样子避免创建同样元素时浪费太多时间构造相同元素，同时模板还支持场景定义
    // 这样可以方便快速的创建同样的组合元素但是不同的上色。
    //
    // 3) 样式
    //
    //  样式是自定义元素外观的关键，应用提供的渲染元素具备了默认的渲染样式，用户无法修改默认的渲染样式，但是我们提供了
    //  一个方法，可以让用户通过修改样式的方法替换默认的渲染行为，以达成自定义样式的效果。同时样式支持状态选择（SwitchState）
    //  以及大纲级别(OutlineLevel)选择等方式，让用户能够修改更多细节上的样式
    //

    /// <summary>
    /// 表示样式引擎,提供样式相关的功能
    /// </summary>
    public sealed class CoreTemplateEngine
    {
        #region StyleCollection / Enumerator

        /// <summary>
        /// 表示用于枚举StyleCollection的枚举器
        /// </summary>
        public struct StyleEnumerator : IEnumerator<Style>
        {
            private StyleCollection m_style;
            private int m_count;

            /// <summary>
            /// 初始化StyleCollection集合枚举器
            /// </summary>
            /// <param name="styles">要枚举的StyleCollection集合</param>
            internal StyleEnumerator(StyleCollection styles)
            {
                m_style = styles;
                m_count = 0;
            }

            /// <summary>
            /// 获取当前位置的元素
            /// </summary>
            public Style Current {
                get {
                    return m_style[m_count];
                }
            }

            /// <summary>
            /// 获取当前位置的元素
            /// </summary>
            object IEnumerator.Current {
                get {
                    return m_style[m_count];
                }
            }

            /// <summary>
            /// 处理并释放资源
            /// </summary>
            public void Dispose()
            {
                m_style = null;
            }

            /// <summary>
            /// 尝试将当前枚举器向下移动一个位置，并返回一个值，该值代表当前移动操作的状态
            /// </summary>
            /// <returns>返回一个值，该值指示当前操作是否完成，如果返回true则操作成功，如果返回false则操作失败</returns>
            public bool MoveNext()
            {
                if(m_count < m_style.Count) {
                    m_count++;
                    return true;
                }
                return false;
            }

            /// <summary>
            /// 重置当前枚举器位置
            /// </summary>
            public void Reset()
            {
                m_count = 0;
            }
        }

        /// <summary>
        /// 表示支持去除重复项的样式集合
        /// </summary>
        public sealed class StyleCollection:IList<Style>,IReadOnlyList<Style>,IEnumerable<Style>,ICollection<Style>
        {
            private List<Style>             m_styleCollection;
            private Dictionary<int,int>     m_classIDMappingDictionary;
            private Dictionary<Type,int>    m_typeMappingDictionary;
            private SynchronizeObject       m_lockObj;


            /// <summary>
            /// 初始化StyleCollection
            /// </summary>
            internal StyleCollection()
            {
                m_styleCollection = new List<Style>();
                m_lockObj = new SynchronizeObject();
                m_classIDMappingDictionary = new Dictionary<int, int>();
                m_typeMappingDictionary = new Dictionary<Type, int>();
            }

            /// <summary>
            /// 添加指定的样式到当前集合之中
            /// </summary>
            /// <param name="item">指定要添加的对象</param>
            public void Add(Style item)
            {
                if (item == null) {
                    throw new ArgumentNullException();
                }

                lock (m_lockObj) {
                    if (!string.IsNullOrEmpty(item.TargetClass)) {
                        var hash = Hash.BKDRHash(item.TargetClass);
                        if (!m_classIDMappingDictionary.ContainsKey(hash)) {                            
                            m_classIDMappingDictionary.Add(hash,m_styleCollection.Count);
                            m_styleCollection.Add(item);
                        }
                    }
                    else if(item.TargetType != null) {
                        m_typeMappingDictionary.Add(item.TargetType, m_styleCollection.Count);
                        m_styleCollection.Add(item);
                    }
                    else {
                        throw new ArgumentNullException();
                    }
                }
            }

            /// <summary>
            /// 清空当前集合
            /// </summary>
            public void Clear()
            {
                lock (m_lockObj) {
                    m_classIDMappingDictionary.Clear();
                    m_styleCollection.Clear();
                    m_typeMappingDictionary.Clear();
                }
            }

            /// <summary>
            /// 获取一个值，该值指示当前集合中是否包含指定的对象
            /// </summary>
            /// <param name="item">指定要比较的对象</param>
            /// <returns>返回一个值，该值指示当前集合中是否包含指定的对象</returns>
            public bool Contains(Style item)
            {
                if (item == null) {
                    throw new ArgumentNullException();
                }

                var result = false;
                lock (m_lockObj) {
                    if (!string.IsNullOrEmpty(item.TargetClass)) {
                        var hash = Hash.BKDRHash(item.TargetClass);
                        result = m_classIDMappingDictionary.ContainsKey(hash);
                        if (result) {
                            return result;
                        }
                    }

                    if (item.TargetType != null) {
                        return m_typeMappingDictionary.ContainsKey(item.TargetType);
                    }
                    else {
                        return false;
                    }
                }
            }

            /// <summary>
            /// 将当前集合复制到指定的数组当中
            /// </summary>
            /// <param name="array">指定复制操作的目标数组</param>
            /// <param name="arrayIndex">指定复制操作的开始位置</param>
            public void CopyTo(Style[] array, int arrayIndex)
            {
                if(arrayIndex< 0 || arrayIndex >= array.Length || arrayIndex + this.Count > array.Length) {
                    throw new IndexOutOfRangeException();
                }

                if (array == null) {
                    throw new ArgumentNullException();
                }

                lock (m_lockObj) {
                    m_styleCollection.CopyTo(array, arrayIndex);
                }
            }

            /// <summary>
            /// 获取用于枚举当前集合的枚举器
            /// </summary>
            /// <returns>返回用于枚举当前集合的枚举器</returns>
            public IEnumerator<Style> GetEnumerator()
            {
                lock (m_lockObj) {
                    return new StyleEnumerator(this);
                }
            }

            /// <summary>
            /// 获取指定元素再当前集合中的位置
            /// </summary>
            /// <param name="item">指定要对比的对象</param>
            /// <returns>返回一个值，该值指示要对比的元素在当前集合中的位置，如果返回-1则表示该元素不存在于当前集合</returns>
            public int IndexOf(Style item)
            {
                if (item == null) {
                    throw new ArgumentNullException();
                }

                lock (m_lockObj) {
                    if (!string.IsNullOrEmpty(item.TargetClass)) {
                        var hash = Hash.BKDRHash(item.TargetClass);
                        if(m_classIDMappingDictionary.ContainsKey(hash)){
                            return m_classIDMappingDictionary[hash];
                        }
                    }

                    if (item.TargetType != null && m_typeMappingDictionary.ContainsKey(item.TargetType)) {
                        return m_typeMappingDictionary[item.TargetType];
                    }
                    return -1;
                }
            }

            /// <summary>
            /// 在指定的位置插入元素
            /// </summary>
            /// <param name="index">指定要出入的位置</param>
            /// <param name="item">指定要插入的对象</param>
            public void Insert(int index, Style item)
            {
                throw new NotSupportedException();
            }

            /// <summary>
            /// 移除指定对象
            /// </summary>
            /// <param name="item">指定要移除的对象</param>
            /// <returns>返回一个值，该值指示当前移除操作是否成功，如果返回true则表示操作成功，返回false则表示操作失败</returns>
            public bool Remove(Style item)
            {
                if(item == null) {
                    return false;
                }

                lock (m_lockObj) {
                    if (!string.IsNullOrEmpty(item.TargetClass)) {
                        var hash = Hash.BKDRHash(item.TargetClass);
                        if (m_classIDMappingDictionary.ContainsKey(hash)) {
                            m_classIDMappingDictionary.Remove(hash);
                            return true;
                        }
                    }

                    if (item.TargetType != null && m_typeMappingDictionary.ContainsKey(item.TargetType)) {
                        m_typeMappingDictionary.Remove(item.TargetType);
                        return true;
                    }

                    return false;
                }
            }

            /// <summary>
            /// 移除指定位置的元素
            /// </summary>
            /// <param name="index">指定要移除的位置</param>
            public void RemoveAt(int index)
            {
                lock (m_lockObj) {
                    if(index < 0 || index >= m_styleCollection.Count) {
                        throw new IndexOutOfRangeException();
                    }

                    var item = m_styleCollection[index];
                    if (!string.IsNullOrEmpty(item.TargetClass)) {
                        m_classIDMappingDictionary.Remove(Hash.BKDRHash(item.TargetClass));
                    }
                    else if(item.TargetType != null) {
                        m_typeMappingDictionary.Remove(item.TargetType);
                    }

                    m_styleCollection.RemoveAt(index);
                }
            }

            /// <summary>
            /// 获取用于枚举当前集合的枚举器
            /// </summary>
            /// <returns>返回用于枚举当前集合的枚举器</returns>
            IEnumerator IEnumerable.GetEnumerator()
            {
                lock (m_lockObj) {
                    return new StyleEnumerator(this);
                }
            }  

            /// <summary>
            /// 获取或设置指定索引位置的值
            /// </summary>
            /// <param name="index">指定的索引位置</param>
            /// <returns>返回指定索引位置的值</returns>
            public Style this[int index] {
                get {
                    lock (m_lockObj) {
                        return m_styleCollection[index];
                    }
                }
                set {
                    lock (m_lockObj) {
                        m_styleCollection[index] = value;
                    }
                }
            }

            /// <summary>
            /// 获取或设置指定类型对应的值
            /// </summary>
            /// <param name="index">指定的类型</param>
            /// <returns>返回指定类型对应的值</returns>
            public Style this[Type type] {
                get {
                    lock (m_lockObj) {
                        if (m_typeMappingDictionary.ContainsKey(type)) {
                            var index = m_typeMappingDictionary[type];
                            return m_styleCollection[index];
                        }
                        return null;
                    }
                }
                set {
                    lock (m_lockObj) {
                        if (m_typeMappingDictionary.ContainsKey(type)) {
                            var index = m_typeMappingDictionary[type];
                            m_styleCollection[index] = value;
                        }
                    }
                }
            }

            /// <summary>
            /// 获取或设置指定关键字对应的值
            /// </summary>
            /// <param name="index">指定的关键字</param>
            /// <returns>返回指定关键字对应的值</returns>
            public Style this[string text] {
                get {
                    var hash = Hash.BKDRHash(text);
                    if (m_classIDMappingDictionary.ContainsKey(hash)) {
                        var index = m_classIDMappingDictionary[hash];
                        return m_styleCollection[index];
                    }
                    return null;
                }
                set {
                    var hash = Hash.BKDRHash(text);
                    if (m_classIDMappingDictionary.ContainsKey(hash)) {
                        var index = m_classIDMappingDictionary[hash];
                        m_styleCollection[index] = value;
                    }
                }
            }

            /// <summary>
            /// 获取当前集合元素的个数
            /// </summary>
            public int Count {
                get {
                    return m_styleCollection.Count;
                }
            }

            /// <summary>
            /// 获取当前集合的只读性
            /// </summary>
            public bool IsReadOnly {
                get {
                    return false;
                }
            }

            #region Override

            /// <summary>
            /// 获取与当前对象等价的字符串形式
            /// </summary>
            /// <returns>返回与当前对象等价的字符串形式</returns>
            public override string ToString()
            {
                return $"count:{m_styleCollection.Count}";
            }

            /// <summary>
            /// 获取当前对象与指定对象之间的等价性
            /// </summary>
            /// <param name="obj">指定要比较的对象</param>
            /// <returns>如果两个对象之间等价则返回true，否则返回false</returns>
            public override bool Equals(object obj)
            {
                if(obj is StyleCollection sc) {
                    return sc.GetHashCode() == this.GetHashCode();
                }
                return false;
            }

            /// <summary>
            /// 获取当前对象的哈希值
            /// </summary>
            /// <returns>返回当前对象的哈希值</returns>
            public override int GetHashCode()
            {
                return m_styleCollection.GetHashCode() + m_styleCollection.Count;
            }
            #endregion

        }

        #endregion

        #region Template / Enumerator

        /// <summary>
        /// 表示用于枚举TemplateCollection的枚举器
        /// </summary>
        public struct TemplateEnumerator : IEnumerator<Template>
        {
            private TemplateCollection m_templateCollection;
            private int m_count;

            /// <summary>
            /// 使用指定的TemplateCollection初始化枚举器
            /// </summary>
            /// <param name="templates">指定要枚举的TemplateCollection集合</param>
            internal TemplateEnumerator(TemplateCollection templates)
            {                
                m_templateCollection = templates;
                m_count = 0;
            }

            /// <summary>
            /// 处理并释放资源
            /// </summary>
            public void Dispose()
            {
                m_templateCollection = null;
            }

            /// <summary>
            /// 获取当前位置的元素
            /// </summary>
            public Template Current {
                get {
                    return m_templateCollection[m_count];
                }
            }

            /// <summary>
            /// 获取当前位置的元素
            /// </summary>
            object IEnumerator.Current {
                get {
                    return m_templateCollection[m_count];
                }
            }

            /// <summary>
            /// 尝试将当前枚举器向下移动一个位置，并返回一个值，该值代表当前移动操作的状态
            /// </summary>
            /// <returns>返回一个值，该值指示当前操作是否完成，如果返回true则操作成功，如果返回false则操作失败</returns>
            public bool MoveNext()
            {
                if (m_count < m_templateCollection.Count) {
                    m_count++;
                    return true;
                }
                return false;
            }

            /// <summary>
            /// 重置当前枚举器位置
            /// </summary>
            public void Reset()
            {
                m_count = 0;
            }

        }

        /// <summary>
        /// 表示支持去除重复项的模板集合
        /// </summary>
        public sealed class TemplateCollection : IList<Template>, IReadOnlyList<Template>, IEnumerable<Template>, ICollection<Template>, IReadOnlyCollection<Template>
        {
            private List<Template>              m_templateCollection;
            private Dictionary<int,int>         m_keywordMappingDictionary;
            private SynchronizeObject           m_lockObj;

            /// <summary>
            /// 初始化TemplateCollection
            /// </summary>
            internal TemplateCollection()
            {
                m_keywordMappingDictionary = new Dictionary<int, int>();
                m_lockObj = new SynchronizeObject();
                m_templateCollection = new List<Template>();
            }

            /// <summary>
            /// 将指定的模板项添加到当前集合
            /// </summary>
            /// <param name="item">指定要添加到当前集合的模板项</param>
            public void Add(Template item)
            {
                if(item == null) {
                    throw new ArgumentNullException();
                }

                lock (m_lockObj) {
                    var hash = Hash.BKDRHash(item.KeyWord);
                    if (!m_keywordMappingDictionary.ContainsKey(hash)) {
                        m_keywordMappingDictionary.Add(hash, m_templateCollection.Count);
                        m_templateCollection.Add(item);
                    }
                }
            }

            /// <summary>
            /// 清空当前集合
            /// </summary>
            public void Clear()
            {
                lock (m_lockObj) {
                    m_keywordMappingDictionary.Clear();
                    m_templateCollection.Clear();
                }
            }

            /// <summary>
            /// 获取一个值，该值指示当前集合中是否存在指定的对象
            /// </summary>
            /// <param name="item">指定要比较的对象</param>
            /// <returns>返回一个值，该值指示当前集合是否存在指定的对象</returns>
            public bool Contains(Template item)
            {
                if(item == null) {
                    throw new ArgumentNullException();
                }

                lock (m_lockObj) {
                    return m_templateCollection.Contains(item);
                }
            }

            /// <summary>
            /// 将当前集合的内容复制到指定的数组
            /// </summary>
            /// <param name="array">指定复制操作的目标数组</param>
            /// <param name="arrayIndex">指定复制操作在目标数组中的位置</param>
            public void CopyTo(Template[] array, int arrayIndex)
            {
                if(array == null) {
                    throw new ArgumentNullException();
                }

                if(array.Length < arrayIndex + this.Count) {
                    throw new IndexOutOfRangeException();
                }

                lock (m_lockObj) {
                    m_templateCollection.CopyTo(array, arrayIndex);
                }
            }

            /// <summary>
            /// 获取用于枚举当前集合的枚举器
            /// </summary>
            /// <returns>返回用于枚举当前集合的枚举器</returns>
            public IEnumerator<Template> GetEnumerator()
            {
                lock (m_lockObj) {
                    return new TemplateEnumerator(this);
                }
            }

            /// <summary>
            /// 获取指定元素再当前集合中的位置
            /// </summary>
            /// <param name="item">指定要对比的对象</param>
            /// <returns>返回一个值，该值指示要对比的元素在当前集合中的位置，如果返回-1则表示该元素不存在于当前集合</returns>
            public int IndexOf(Template item)
            {
                throw new NotImplementedException();
            }

            /// <summary>
            /// 在指定的位置插入元素
            /// </summary>
            /// <param name="index">指定要出入的位置</param>
            /// <param name="item">指定要插入的对象</param>
            public void Insert(int index, Template item)
            {
                throw new NotSupportedException();
            }

            /// <summary>
            /// 移除指定对象
            /// </summary>
            /// <param name="item">指定要移除的对象</param>
            /// <returns>返回一个值，该值指示当前移除操作是否成功，如果返回true则表示操作成功，返回false则表示操作失败</returns>
            public bool Remove(Template item)
            {
                if(item == null) {
                    throw new ArgumentNullException();
                }

                lock (m_lockObj) {
                    var hash = Hash.BKDRHash(item.KeyWord);
                    if (m_keywordMappingDictionary.ContainsKey(hash)) {
                        var index = m_keywordMappingDictionary[hash];
                        m_templateCollection.RemoveAt(index);
                        return m_keywordMappingDictionary.Remove(hash);
                    }
                    return false;
                }
            }

            /// <summary>
            /// 移除指定位置的元素
            /// </summary>
            /// <param name="index">指定要移除的位置</param>
            public void RemoveAt(int index)
            {
                if(index < 0 || index >= m_templateCollection.Count) {
                    throw new IndexOutOfRangeException();
                }

                lock (m_lockObj) {
                    var item = m_templateCollection[index];
                    var hash = Hash.BKDRHash(item.KeyWord);
                    m_keywordMappingDictionary.Remove(hash);
                    m_templateCollection.RemoveAt(index);
                }
            }

            /// <summary>
            /// 获取用于枚举当前集合的枚举器
            /// </summary>
            /// <returns>返回用于枚举当前集合的枚举器</returns>
            IEnumerator IEnumerable.GetEnumerator()
            {
                lock (m_lockObj) {
                    return new TemplateEnumerator(this);
                }
            }

            /// <summary>
            /// 获取或设置指定索引位置的值
            /// </summary>
            /// <param name="index">指定的索引位置</param>
            /// <returns>返回指定索引位置的值</returns>
            public Template this[int index] {
                get {
                    lock (m_lockObj) {
                        return m_templateCollection[index];
                    }
                }
                set {
                    lock (m_lockObj) {
                        m_templateCollection[index] = value;
                    }
                }
            }

            /// <summary>
            /// 获取或设置指定关键字对应的值
            /// </summary>
            /// <param name="index">指定的关键字</param>
            /// <returns>返回指定关键字对应的值</returns>
            public Template this[string text] {
                get {
                    lock (m_lockObj) {
                        var hash = Hash.BKDRHash(text);
                        if (m_keywordMappingDictionary.ContainsKey(hash)) {
                            var index = m_keywordMappingDictionary[hash];
                            return m_templateCollection[index];
                        }
                        return null;
                    }
                }
            }

            /// <summary>
            /// 获取当前集合元素的个数
            /// </summary>
            public int Count {
                get {
                    return m_templateCollection.Count;
                }
            }

            /// <summary>
            /// 获取当前集合的只读性
            /// </summary>
            public bool IsReadOnly {
                get {
                    return false;
                }
            }

            #region Override

            /// <summary>
            /// 获取与当前对象等价的字符串形式
            /// </summary>
            /// <returns>返回与当前对象等价的字符串形式</returns>
            public override string ToString()
            {
                return $"count:{m_templateCollection.Count}";
            }

            /// <summary>
            /// 获取当前对象与指定对象之间的等价性
            /// </summary>
            /// <param name="obj">指定要比较的对象</param>
            /// <returns>如果两个对象之间等价则返回true，否则返回false</returns>
            public override bool Equals(object obj)
            {
                if(obj is TemplateCollection tc) {
                    return tc.GetHashCode() == this.GetHashCode();
                }
                return false;
            }

            /// <summary>
            /// 获取当前对象的哈希值
            /// </summary>
            /// <returns>返回当前对象的哈希值</returns>
            public override int GetHashCode()
            {
                return m_templateCollection.GetHashCode() + m_templateCollection.Count;
            }
            #endregion

        }

        #endregion

        /*
         * 样式包括模板样式、元素样式
         */
        private StyleCollection                     m_styleDictionary;          // nameTable用于将字符串哈希化,以节省整个CoreTemplateEngine的内存占用
        private SynchronizeObject                   m_lockObj;                  // 所有以string作为关键词的字典都不需要再保存一份string副本，只需要存储
        private TemplateCollection                  m_templateDictionary;       // 一个4字节的ID即可                        

        #region Constructor

        /// <summary>
        /// 
        /// </summary>
        internal CoreTemplateEngine()
        {
            m_styleDictionary = new StyleCollection();         
            m_templateDictionary = new TemplateCollection();
            m_lockObj = new SynchronizeObject();
        }

        #endregion

        #region Get / Set / Remove Style

        /// <summary>
        /// 
        /// </summary>
        /// <param name="style"></param>
        public void SetStyle(Style style)
        {
            // StyleCollection在实现上已经是加锁的
            // 如果在该方法中再次加锁并不确保会不会产生死锁
            // 因为理论上不会产生死锁
            m_styleDictionary.Add(style);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="classId"></param>
        /// <returns></returns>
        public Style GetStyle(string classId)
        {
            return m_styleDictionary[classId];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public Style GetStyle(Type type)
        {
            return m_styleDictionary[type];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="style"></param>
        public void RemoveStyle(Style style)
        {
            m_styleDictionary.Remove(style);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public IEnumerator<Style> GetStyles()
        {
            lock (m_lockObj) {
                return m_styleDictionary.GetEnumerator();
            }
        }
        #endregion

        #region Get / Set / Remove Template

        /// <summary>
        /// 
        /// </summary>
        /// <param name="template"></param>
        public void SetTemplate(Template template)
        {
            m_templateDictionary.Add(template);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="keyword"></param>
        /// <returns></returns>
        public Template GetTemplate(string keyword)
        {
            return m_templateDictionary[keyword];
        }

        /// <summary>
        /// 
        /// </summary>
        public void RemoveTemplate(string keyword)
        {
            m_templateDictionary.Remove(m_templateDictionary[keyword]);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public IEnumerator<Template> GetEnumerator()
        {
            return m_templateDictionary.GetEnumerator();
        }

        #endregion

        #region Load / Save Templatre

        #endregion

        #region Load / Save Style

        #endregion

        public void Composition(RenderTree renderTree) {

        }

        #region Property

        /// <summary>
        /// 获取当前模板引擎导入的只读模板集合
        /// </summary>
        public IReadOnlyList<Template> Templates {
            get { return m_templateDictionary; }
        }

        /// <summary>
        /// 获取当前模板引擎导入的只读样式集合
        /// </summary>
        public IReadOnlyList<Style> Styles {
            get { return m_styleDictionary; }
        }

        #endregion

        #region Override

        /// <summary>
        /// 获取与当前对象等价的字符串形式
        /// </summary>
        /// <returns>返回与当前对象等价的字符串形式</returns>
        public override string ToString()
        {
            return $"style:{m_styleDictionary.Count},template:{m_templateDictionary.Count}";
        }

        /// <summary>
        /// 获取当前对象与指定对象之间的等价性
        /// </summary>
        /// <param name="obj">指定要比较的对象</param>
        /// <returns>如果两个对象之间等价则返回true，否则返回false</returns>
        public override bool Equals(object obj)
        {
            if(obj is CoreTemplateEngine cte) {
                return cte.GetHashCode() == this.GetHashCode();
            }
            return false;
        }

        /// <summary>
        /// 获取当前对象的哈希值
        /// </summary>
        /// <returns>返回当前对象的哈希值</returns>
        public override int GetHashCode()
        {
            return m_templateDictionary.GetHashCode() ^ m_styleDictionary.GetHashCode();
        }
        #endregion

    }
}
